{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|default_exp calibration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calibration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Functionality to calibrate a trained, binary classification model using temperature scaling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "from tsai.imports import *\n",
    "from sklearn.calibration import calibration_curve\n",
    "from tsai.data.core import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class ModelWithTemperature(nn.Module):\n",
    "    \"\"\" A decorator which wraps a model with temperature scaling \"\"\"\n",
    "\n",
    "    def __init__(self, model):\n",
    "        super().__init__()\n",
    "        self.model = model\n",
    "        self.temperature = nn.Parameter(torch.ones(1,1))\n",
    "\n",
    "    def forward(self, input):\n",
    "        logits = self.model(input)\n",
    "        return self.temperature_scale(logits)\n",
    "\n",
    "    def temperature_scale(self, logits):\n",
    "        temperature = self.temperature.expand(logits.size(0), logits.size(1)).to(logits.device)\n",
    "        return torch.div(logits, temperature)\n",
    "\n",
    "\n",
    "class TemperatureSetter(nn.Module):\n",
    "    \"\"\" Calibrates a binary classification model optimizing temperature \"\"\"\n",
    "\n",
    "    def __init__(self, model, lr=0.01, max_iter=1_000, line_search_fn=None, n_bins=10, verbose=True):\n",
    "        super().__init__()\n",
    "        self.model = ModelWithTemperature(model) if not hasattr(model, 'temperature_scale') else model\n",
    "        self.lr, self.max_iter, self.line_search_fn, self.n_bins, self.verbose = lr, max_iter, line_search_fn, n_bins, verbose\n",
    "        self.nll_criterion = CrossEntropyLossFlat()\n",
    "        self.ece_criterion = ECELoss(n_bins)\n",
    "\n",
    "    def forward(self, dl):\n",
    "        logits_list = []\n",
    "        labels_list = []\n",
    "        with torch.no_grad():\n",
    "            for input, label in dl:\n",
    "                logits = self.model(input)\n",
    "                logits_list.append(logits)\n",
    "                labels_list.append(label)\n",
    "            logits = torch.cat(logits_list)\n",
    "            labels = torch.cat(labels_list)\n",
    "\n",
    "        if self.verbose:\n",
    "            before_temperature_nll = self.nll_criterion(logits, labels).item()\n",
    "            before_temperature_ece = self.ece_criterion(logits, labels).item()\n",
    "            print(f'Before temperature - NLL: {before_temperature_nll:.3f}, ECE: {before_temperature_ece:.3f}')\n",
    "\n",
    "        optimizer = torch.optim.LBFGS([self.model.temperature], lr=self.lr, max_iter=self.max_iter, line_search_fn=self.line_search_fn)\n",
    "\n",
    "        def _evaluation():\n",
    "            optimizer.zero_grad()\n",
    "            loss = self.nll_criterion(self.model.temperature_scale(logits), labels)\n",
    "            loss.backward()\n",
    "            return loss\n",
    "\n",
    "        pv('Calibrating the model...', self.verbose)\n",
    "        optimizer.step(_evaluation)\n",
    "        pv('...model calibrated', self.verbose)\n",
    "\n",
    "        if self.verbose:\n",
    "            after_temperature_nll = self.nll_criterion(self.model.temperature_scale(logits), labels).item()\n",
    "            after_temperature_ece = self.ece_criterion(self.model.temperature_scale(logits), labels).item()\n",
    "            print(f'Optimal temperature: {self.model.temperature.item():.3f}')\n",
    "            print(f'After temperature  - NLL: {after_temperature_nll:.3f}, ECE: {after_temperature_ece:.3f}\\n')\n",
    "\n",
    "        self.logits = logits\n",
    "        self.scaled_logits = self.model.temperature_scale(logits)\n",
    "        self.labels = labels\n",
    "        self.calibrated_model = self.model\n",
    "        return self.calibrated_model\n",
    "\n",
    "\n",
    "class ECELoss(nn.Module):\n",
    "    \"\"\"Calculates the Expected Calibration Error of a model.\"\"\"\n",
    "    def __init__(self, n_bins=10):\n",
    "        super().__init__()\n",
    "        bin_boundaries = torch.linspace(0, 1, n_bins + 1)\n",
    "        self.bin_lowers = bin_boundaries[:-1]\n",
    "        self.bin_uppers = bin_boundaries[1:]\n",
    "\n",
    "    def forward(self, logits, labels):\n",
    "        softmaxes = F.softmax(logits, dim=1)\n",
    "        confidences, predictions = torch.max(softmaxes, 1)\n",
    "        if isinstance(softmaxes, TSTensor):\n",
    "            confidences, predictions = confidences.data, predictions.data\n",
    "        accuracies = torch.eq(predictions.data, labels)\n",
    "\n",
    "        ece = torch.zeros(1, device=logits.device)\n",
    "        for bin_lower, bin_upper in zip(self.bin_lowers, self.bin_uppers):\n",
    "            # Calculated |confidence - accuracy| in each bin\n",
    "            in_bin = confidences.gt(bin_lower.item()) * confidences.le(bin_upper.item())\n",
    "            prop_in_bin = in_bin.float().mean()\n",
    "            if prop_in_bin.item() > 0:\n",
    "                accuracy_in_bin = accuracies[in_bin].float().mean()\n",
    "                avg_confidence_in_bin = confidences[in_bin].mean()\n",
    "                ece += torch.abs(avg_confidence_in_bin - accuracy_in_bin) * prop_in_bin\n",
    "        return ece"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def plot_calibration_curve(labels, logits, cal_logits=None, figsize=(6,6), n_bins=10, strategy='uniform'):\n",
    "    y_true = labels.cpu().numpy()\n",
    "    pos_probas = F.softmax(logits, dim=1)[:, 1].detach().cpu().numpy()\n",
    "    nn_y, nn_x = calibration_curve(y_true, pos_probas, n_bins=n_bins, strategy=strategy)\n",
    "    fig, ax = plt.subplots(figsize=figsize)\n",
    "    fig.suptitle(\"Calibration plot\", fontsize=16)\n",
    "    ax.plot(nn_x, nn_y, marker=\"o\", linewidth=1, color='orange', label='probas')\n",
    "    if cal_logits is not None:\n",
    "        pos_cal_probas = F.softmax(cal_logits, dim=1)[:, 1].detach().cpu().numpy()\n",
    "        cal_nn_y, cal_nn_x = calibration_curve(y_true, pos_cal_probas, n_bins=n_bins, strategy=strategy)\n",
    "        ax.plot(cal_nn_x, cal_nn_y, marker=\"o\", linewidth=1, color='purple', label='calibrated probas')\n",
    "    ax.plot([0, 1], [0, 1], transform=ax.transAxes, color='gray', lw=1)\n",
    "    ax.set_xlabel(\"Predicted probability\", fontsize=12)\n",
    "    ax.set_ylabel(\"True probability in each bin\", fontsize=12)\n",
    "    ax.set_xticks(np.linspace(0,1,11))\n",
    "    ax.set_yticks(np.linspace(0,1,11))\n",
    "    ax.set_xlim(0,1)\n",
    "    ax.set_ylim(0,1)\n",
    "    initial_ECE = ECELoss(n_bins)(logits, labels).item()\n",
    "    if cal_logits is not None:\n",
    "        final_ECE = ECELoss(n_bins)(cal_logits, labels).item()\n",
    "        title = f\"initial ECE: {initial_ECE:.3f} - final ECE: {final_ECE:.3f}\"\n",
    "    else:\n",
    "        title = f\"ECE: {initial_ECE:.3f}\"\n",
    "    plt.title(title)\n",
    "    plt.legend(loc='best')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "@patch\n",
    "def calibrate_model(self:Learner, X=None, y=None, lr=1e-2, max_iter=10_000, line_search_fn=None, n_bins=10, strategy='uniform',\n",
    "                    show_plot=True, figsize=(6,6), verbose=True):\n",
    "    if X is not None and y is not None:\n",
    "        dl = self.dls.valid.new_dl(X, y)\n",
    "    else:\n",
    "        dl = self.dls.valid\n",
    "    assert dl.c == 2, \"calibrate_model is only available for binary classification tasks\"\n",
    "    temp_setter = TemperatureSetter(self.model, lr=lr, max_iter=max_iter, line_search_fn=line_search_fn, n_bins=n_bins, verbose=verbose)\n",
    "    self.calibrated_model = temp_setter(dl)\n",
    "    if show_plot:\n",
    "        plot_calibration_curve(temp_setter.labels, temp_setter.logits, temp_setter.scaled_logits, n_bins=n_bins, strategy=strategy, figsize=figsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tsai.basics import *\n",
    "from tsai.models.FCNPlus import FCNPlus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.724956</td>\n",
       "      <td>nan</td>\n",
       "      <td>nan</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.713688</td>\n",
       "      <td>nan</td>\n",
       "      <td>nan</td>\n",
       "      <td>00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/nacho/notebooks/tsai/tsai/data/core.py:648: RuntimeWarning: overflow encountered in scalar add\n",
      "  b = slice(b[0], min(self.n, b[0] + self.bs))\n"
     ]
    }
   ],
   "source": [
    "X, y, splits = get_UCR_data('FingerMovements', split_data=False)\n",
    "tfms  = [None, [TSClassification()]]\n",
    "batch_tfms = TSRobustScale()\n",
    "dls = get_ts_dls(X, y, splits=splits, tfms=tfms, batch_tfms=batch_tfms)\n",
    "learn = ts_learner(dls, FCNPlus, metrics=accuracy)\n",
    "learn.fit_one_cycle(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before temperature - NLL: 0.696, ECE: 0.032\n",
      "Calibrating the model...\n",
      "...model calibrated\n",
      "Optimal temperature: 3.641\n",
      "After temperature  - NLL: 0.693, ECE: 0.018\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.calibrate_model()\n",
    "calibrated_model = learn.calibrated_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": "IPython.notebook.save_checkpoint();",
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/nacho/notebooks/tsai/nbs/021_calibration.ipynb saved at 2025-01-18 17:43:29\n",
      "Correct notebook to script conversion! 😃\n",
      "Saturday 18/01/25 17:43:32 CET\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "                <audio  controls=\"controls\" autoplay=\"autoplay\">\n",
       "                    <source src=\"data:audio/wav;base64,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\" type=\"audio/wav\" />\n",
       "                    Your browser does not support the audio element.\n",
       "                </audio>\n",
       "              "
      ],
      "text/plain": [
       "<IPython.lib.display.Audio object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#|eval: false\n",
    "#|hide\n",
    "from tsai.export import get_nb_name; nb_name = get_nb_name(locals())\n",
    "from tsai.imports import create_scripts; create_scripts(nb_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
